// 食饭点评小程序API模块

// 基础URL配置
const baseUrl = 'http://120.76.157.24:3001/api/v1';

// 请求方法封装
function request(options) {
    return new Promise((resolve, reject) => {
        // 获取token
        const token = wx.getStorageSync('token');

        // 记录请求信息，便于调试
        console.log(`API请求: ${options.url}`);
        if (options.data) {
            console.log('请求参数:', JSON.stringify(options.data, null, 2));
        }

        // 构建请求头
        const header = {
            'Content-Type': 'application/json'
        };

        // 如果有token则添加到请求头
        if (token && options.url !== '/auth/login') {
            header['Authorization'] = `Bearer ${token}`;
            console.log('使用token:', token);
        }

        // 登录请求不需要进行token自动登录处理
        if (options.url === '/auth/login') {
            makeRequest();
            return;
        }

        // 非登录请求，如果没有token，先尝试登录
        if (!token) {
            // Token不存在，尝试自动登录并获取Token
            console.log('无token，尝试自动登录');
            autoLogin().then(newToken => {
                // 自动登录成功，使用新token重试请求
                if (newToken) {
                    header['Authorization'] = `Bearer ${newToken}`;
                    makeRequest();
                } else {
                    reject({ errMsg: '登录失败，无法获取授权', statusCode: 401 });
                }
            }).catch(err => {
                reject({ errMsg: '自动登录失败', statusCode: 401, error: err });
            });
            return; // 避免重复发起请求
        }

        makeRequest();

        function makeRequest() {
            // 如果是用模拟登录token请求收藏相关API，直接返回模拟数据
            const isMockToken = token && token.startsWith('mock_token_');
            if (isMockToken) {
                // 收藏相关API的模拟数据处理
                if (options.url === '/favorites') {
                    console.log('使用模拟数据返回收藏列表');
                    const mockResponse = {
                        code: 0,
                        message: 'success',
                        data: {
                            restaurants: [],
                            total: 0,
                            page: options.data?.page || 1,
                            pageSize: options.data?.pageSize || 10,
                            hasMore: false
                        }
                    };
                    resolve(mockResponse);
                    return;
                }

                // 收藏相关的操作模拟成功响应
                if (options.url.includes('/favorite')) {
                    console.log('模拟收藏操作成功');
                    const mockResponse = {
                        code: 0,
                        message: 'success',
                        data: { isFavorite: options.data?.isFavorite || false }
                    };
                    resolve(mockResponse);
                    return;
                }

                // 批量删除收藏
                if (options.url === '/favorites/batch-delete') {
                    console.log('模拟批量删除收藏成功');
                    const mockResponse = {
                        code: 0,
                        message: 'success',
                        data: { deletedCount: (options.data?.ids || []).length }
                    };
                    resolve(mockResponse);
                    return;
                }
            }

            // 发起请求
            wx.request({
                url: options.url.indexOf('http') === 0 ? options.url : baseUrl + options.url,
                method: options.method || 'GET',
                data: options.data || {},
                header: header,
                success: res => {
                    // 记录响应信息
                    console.log(`API响应: ${options.url}, 状态:`, res.statusCode);
                    console.log('响应数据:', JSON.stringify(res.data).substring(0, 500) + (JSON.stringify(res.data).length > 500 ? '...(数据过长)' : ''));

                    // 登录接口的特殊处理
                    if (options.url === '/auth/login') {
                        // 即使状态码不是200，也返回整个响应，由调用方处理
                        resolve(res.data);
                        return;
                    }

                    if (res.statusCode === 200) {
                        // 处理餐厅数据，将_id映射为id，处理图片路径
                        if (res.data && res.data.data) {
                            // 处理餐厅列表数据（rankings接口）
                            if (res.data.data.restaurants && Array.isArray(res.data.data.restaurants)) {
                                res.data.data.restaurants = res.data.data.restaurants.map(restaurant => {
                                    // 将_id赋值给id字段
                                    if (restaurant._id && !restaurant.id) {
                                        restaurant.id = restaurant._id;
                                    }

                                    // 处理图片路径，转换为完整URL
                                    if (restaurant.image && restaurant.image.startsWith('/uploads/')) {
                                        restaurant.image = baseUrl.replace('/api/v1', '') + restaurant.image;
                                    }

                                    // 处理图片集合
                                    if (restaurant.photos && Array.isArray(restaurant.photos)) {
                                        restaurant.photos = restaurant.photos.map(photo => {
                                            if (photo.url && photo.url.startsWith('/uploads/')) {
                                                photo.url = baseUrl.replace('/api/v1', '') + photo.url;
                                            }
                                            return photo;
                                        });
                                    }

                                    return restaurant;
                                });
                            }

                            // 处理单个餐厅数据（restaurant详情接口）
                            if (res.data.data && res.data.data._id && !res.data.data.id) {
                                res.data.data.id = res.data.data._id;

                                // 处理单个餐厅的图片路径
                                if (res.data.data.image && res.data.data.image.startsWith('/uploads/')) {
                                    res.data.data.image = baseUrl.replace('/api/v1', '') + res.data.data.image;
                                }

                                // 处理图片集合
                                if (res.data.data.photos && Array.isArray(res.data.data.photos)) {
                                    res.data.data.photos = res.data.data.photos.map(photo => {
                                        if (photo.url && photo.url.startsWith('/uploads/')) {
                                            photo.url = baseUrl.replace('/api/v1', '') + photo.url;
                                        }
                                        return photo;
                                    });
                                }
                            }
                        }

                        resolve(res.data);
                    } else if (res.statusCode === 401) {
                        // 处理token过期的情况
                        console.log('Token无效或已过期，尝试重新登录');

                        // 清除旧token
                        wx.removeStorageSync('token');
                        wx.removeStorageSync('tokenExpireTime');

                        // 尝试自动登录一次
                        autoLogin().then(newToken => {
                            if (newToken) {
                                // 自动登录成功，使用新token重试请求
                                const newHeader = Object.assign({}, header);
                                newHeader['Authorization'] = `Bearer ${newToken}`;

                                wx.request({
                                    url: options.url.indexOf('http') === 0 ? options.url : baseUrl + options.url,
                                    method: options.method || 'GET',
                                    data: options.data || {},
                                    header: newHeader,
                                    success: newRes => {
                                        if (newRes.statusCode === 200) {
                                            resolve(newRes.data);
                                        } else {
                                            reject({ errMsg: '重试请求失败', statusCode: newRes.statusCode, data: newRes.data });
                                        }
                                    },
                                    fail: err => reject(err)
                                });
                            } else {
                                // 自动登录也失败但使用模拟token时，尝试返回模拟数据
                                if (isMockToken && options.url === '/favorites') {
                                    const mockResponse = {
                                        code: 0,
                                        message: 'success',
                                        data: {
                                            restaurants: [],
                                            total: 0,
                                            page: options.data?.page || 1,
                                            pageSize: options.data?.pageSize || 10,
                                            hasMore: false
                                        }
                                    };
                                    resolve(mockResponse);
                                    return;
                                }

                                // 自动登录也失败，提示用户手动登录
                                wx.showToast({
                                    title: '登录信息已过期，请重新登录',
                                    icon: 'none'
                                });
                                reject({ errMsg: '登录已过期', statusCode: 401 });
                            }
                        }).catch(() => {
                            reject({ errMsg: '自动登录失败', statusCode: 401 });
                        });
                        return;
                    } else {
                        reject({
                            errMsg: `请求失败: ${res.statusCode}`,
                            statusCode: res.statusCode,
                            data: res.data
                        });
                    }
                },
                fail: err => {
                    console.error(`API请求失败: ${options.url}`, err);
                    reject(err);
                }
            });
        }
    });
}

// 自动登录方法
function autoLogin() {
    return new Promise((resolve, reject) => {
        wx.login({
            success: res => {
                if (res.code) {
                    console.log('微信登录成功，获取到code:', res.code);

                    // 直接使用wx.request，绕过request函数
                    wx.request({
                        url: `${baseUrl}/auth/login`,
                        method: 'POST',
                        data: { code: res.code },
                        header: {
                            'Content-Type': 'application/json'
                        },
                        success: loginRes => {
                            console.log('登录API返回状态码:', loginRes.statusCode);
                            console.log('登录API返回数据:', JSON.stringify(loginRes.data, null, 2));

                            // 处理500服务器错误
                            if (loginRes.statusCode === 500) {
                                console.error('登录失败，服务器返回500错误:', loginRes.data.message);
                                console.log('尝试使用模拟登录代替');
                                // 服务器错误时，尝试使用模拟登录
                                mockLogin().then(token => {
                                    resolve(token);
                                }).catch(err => {
                                    resolve(null);
                                });
                                return;
                            }

                            // 即使状态码是400也尝试解析数据
                            if (loginRes.statusCode === 400) {
                                if (loginRes.data && loginRes.data.message) {
                                    console.error('登录失败，服务器返回400错误:', loginRes.data.message);
                                }
                                resolve(null); // 登录失败
                                return;
                            }

                            if (loginRes.statusCode === 200 &&
                                loginRes.data &&
                                loginRes.data.code === 0 &&
                                loginRes.data.data &&
                                loginRes.data.data.token) {

                                const token = loginRes.data.data.token;
                                const userId = loginRes.data.data.userId;
                                const expiresIn = loginRes.data.data.expiresIn || 3600;

                                // 保存token到本地
                                wx.setStorageSync('token', token);

                                // 保存userId
                                if (userId) {
                                    wx.setStorageSync('userId', userId);
                                }

                                // 设置token过期时间（根据服务器返回的expiresIn）
                                const expireTime = Date.now() + expiresIn * 1000;
                                wx.setStorageSync('tokenExpireTime', expireTime);

                                // 登录成功
                                console.log('登录成功，获取token成功');
                                resolve(token);
                            } else {
                                let errorMsg = '未知错误';
                                if (loginRes.data && loginRes.data.message) {
                                    errorMsg = loginRes.data.message;
                                }
                                console.error('登录失败，错误信息:', errorMsg);
                                resolve(null); // 登录失败
                            }
                        },
                        fail: err => {
                            console.error('登录请求失败:', err);
                            // 请求失败时，尝试使用模拟登录
                            console.log('请求失败，尝试使用模拟登录代替');
                            mockLogin().then(token => {
                                resolve(token);
                            }).catch(err => {
                                resolve(null);
                            });
                        }
                    });
                } else {
                    console.error('wx.login获取code失败');
                    resolve(null);
                }
            },
            fail: err => {
                console.error('wx.login调用失败:', err);
                resolve(null);
            }
        });
    });
}

// 获取用户资料
function getUserProfile() {
    return request({
        url: '/user/profile',
        method: 'GET'
    });
}

// 模拟登录，用于开发环境测试
function mockLogin() {
    console.log('使用模拟登录');
    const mockToken = 'mock_token_' + Date.now();
    const mockUserId = 'user_' + Math.floor(Math.random() * 1000);

    // 保存模拟token
    wx.setStorageSync('token', mockToken);
    wx.setStorageSync('userId', mockUserId);

    // 设置过期时间为1小时后
    const expireTime = Date.now() + 3600 * 1000;
    wx.setStorageSync('tokenExpireTime', expireTime);

    console.log('模拟登录成功，token:', mockToken);
    return Promise.resolve(mockToken);
}

// 导出API方法
module.exports = {
    baseUrl,

    // 模拟登录（仅用于开发测试）
    mockLogin,

    // 用户相关
    login: (code) => {
        console.log('调用登录接口，code:', code);
        return request({
            url: '/auth/login',
            method: 'POST',
            data: { code }
        });
    },

    // 获取排行榜数据
    getRankings: (params) => {
        return request({
            url: '/rankings',
            method: 'GET',
            data: params
        });
    },

    // 获取特色餐厅
    getFeaturedRestaurant: () => {
        return request({
            url: '/restaurants/featured',
            method: 'GET'
        });
    },

    // 获取餐厅详情
    getRestaurantDetail: (id) => {
        // 防止id为undefined导致请求错误
        if (!id) {
            return Promise.reject({
                errMsg: '餐厅ID不能为空',
                statusCode: 400
            });
        }
        return request({
            url: `/restaurants/${id}`,
            method: 'GET'
        });
    },

    // 获取收藏列表
    getFavorites: (params) => {
        return request({
            url: '/favorites',
            method: 'GET',
            data: params
        });
    },

    // 添加/取消收藏
    toggleFavorite: (id, isFavorite) => {
        return request({
            url: `/restaurants/${id}/favorite`,
            method: 'POST',
            data: { isFavorite }
        });
    },

    // 取消收藏（为兼容favorites.js中的调用）
    removeFavorite: (id) => {
        return request({
            url: `/restaurants/${id}/favorite`,
            method: 'POST',
            data: { isFavorite: false }
        });
    },

    // 批量取消收藏
    batchDeleteFavorites: (ids) => {
        return request({
            url: '/favorites/batch-delete',
            method: 'POST',
            data: { ids }
        });
    },

    // 评分
    rateRestaurant: (id, score) => {
        return request({
            url: `/restaurants/${id}/rating`,
            method: 'POST',
            data: { score }
        });
    },

    // 删除评分
    deleteRating: (id) => {
        return request({
            url: `/restaurants/${id}/rating`,
            method: 'DELETE'
        });
    },

    // 获取导航信息
    getNavigation: (id, userLatitude, userLongitude) => {
        return request({
            url: `/restaurants/${id}/navigation`,
            method: 'GET',
            data: {
                userLatitude,
                userLongitude
            }
        });
    },

    // 更新用户资料
    updateUserProfile: (profileData) => {
        return request({
            url: '/user/profile',
            method: 'POST',
            data: profileData
        });
    },

    // 获取用户资料
    getUserProfile,

    // 评分相关
    addReview: (restaurantId, data) => {
        return request({
            url: '/reviews',
            method: 'POST',
            data: Object.assign({ restaurantId }, data)
        });
    },

    // 导出自动登录方法供其他地方使用
    autoLogin
}; 